<h1 id="-">第三章</h1>
<hr>
<h2 id="-">字符串和范围</h2>
<p>到目前为止，我已经在我的程序中使用了很多字符串（String）。事实上，在本书中的第一个程序中就有字符串。这里再给出来：</p>
<pre><code><span class="hljs-attribute">puts</span> <span class="hljs-string">'hello world'</span></code></pre><p>在第一个程序中字符串使用单引号作为分隔符，我在第二个程序中则使用了双引号来替换：</p>
<pre><code><span class="hljs-function"><span class="hljs-title">print</span>(<span class="hljs-string">'Enter your name: '</span>)</span>
<span class="hljs-variable">name</span> = <span class="hljs-function"><span class="hljs-title">gets</span>()</span>
<span class="hljs-function"><span class="hljs-title">puts</span>(<span class="hljs-string">"Hello #{name}"</span>)</span></code></pre><div class="code-file clearfix"><span>1strings.rb</span></div>

<p>双引号字符串要比单引号字符串做更多的工作。尤其地，即便字符串是代码它也有能力去执行。要执行代码的话，请使用 <code>#</code> 字符与大括号将其包含进去。</p>
<p>在上面的示例中，<code>#{name}</code> 在双引号字符串中指示 Ruby 获取 <code>name</code> 变量的值并将其插入到字符串中。所以，如果 <code>name</code> 等于 &quot;Fred&quot;，将会显示 &quot;Hello Fred&quot;。<strong>1strings.rb</strong> 示例程序提供了双引号字符串中嵌入式表达式的更多示例。</p>
<p>双引号字符串不仅能够执行获取属性或者变量的值，例如 <code>ob.name</code>，还有诸如 <code>2*3</code> 的表达式，方法调用 <code>ob.ten</code>（<strong>ten</strong> 是一个方法名）以及转义字符换行符 &quot;\n&quot; 和制表符 &quot;\t&quot; 都能被识别执行。</p>
<p>单引号字符串则不会执行这些。并且，单引号字符串可以使用反斜杠表示下一个字符仅仅表示其字面意思。当一个单引号字符串中包含单引号时，这是非常有用的：</p>
<pre><code><span class="hljs-symbol">'It</span>\<span class="hljs-symbol">'s</span> my party'</code></pre><p>假设名为 <code>ten</code> 的方法返回值为10，你可以写出下面的代码：</p>
<pre><code>puts<span class="hljs-comment">("Here's a tab\t a new line\n a calculation #{2*3} and a method-call #{ob.ten}")</span></code></pre><p>由于这是双引号字符串，因此将执行嵌入式表达式，并显示以下内容：</p>
<pre><code>Here's a <span class="hljs-built_in">tab</span>    a <span class="hljs-keyword">new</span> <span class="hljs-keyword">line</span>
a calculation <span class="hljs-number">6</span> <span class="hljs-keyword">and</span> a method-<span class="hljs-keyword">call</span> <span class="hljs-number">10</span></code></pre><p>接下来，让我们看当使用单引号时会发生什么：</p>
<pre><code>puts(<span class="hljs-string">'Here\'</span>s a tab\t a <span class="hljs-keyword">new</span> line\n a calculation #<span class="hljs-comment">{2*3}</span> <span class="hljs-keyword">and</span> a <span class="hljs-function"><span class="hljs-keyword">method</span>-<span class="hljs-title">call</span> #<span class="hljs-comment">{ob.ten}</span>')</span></code></pre><p>这一次，嵌入式表达式将不会被执行，所以将显示：</p>
<pre><code>Here<span class="hljs-comment">'s a tab\t a new line\n a calculation #{2*3} and a method-call #{ob.ten}</span></code></pre><h3 id="-">用户自定义字符串分隔符</h3>
<p>如果由于某些原因，使用单双引号不方便，例如你的字符串包含很多的引号，而你不想总是使用反斜杠去转义，那么你也可以通过其它方式去分割字符串。</p>
<div class="code-file clearfix"><span>2strings.rb</span></div>

<p>双引号的标准替代分隔符是 <strong>%Q</strong> 和 <strong>/</strong> 或者 <strong>%/</strong> 和 <strong>/</strong> ，然而单引号则为 <strong>%q</strong> 和 <strong>/</strong> 。因此：</p>
<pre><code>%Q/This is the same as a<span class="hljs-built_in"> double-quoted </span>string./
%/This is also the same as a<span class="hljs-built_in"> double-quoted </span>string./
%q/And this is the same as a single-quoted string/</code></pre><p>你甚至可以定义自己的字符串分隔符。它们必须是非字母数字字符,可以包含非打印字符，比如换行符和通常在 Ruby 中有特殊含义的字符，例如 <code>#</code>。你选择的字符应该放在 <strong>%Q</strong> 或 <strong>%q</strong> 之后，并且应该确保终止字符串的是同样的字符。如果你使用的分隔符是一个开括号，相应的在字符串结尾处应该使用闭括号，像这样：</p>
<pre><code>%Q[This <span class="hljs-keyword">is</span> a <span class="hljs-built_in">string</span>]</code></pre><div class="code-file clearfix"><span>3strings.rb</span></div>

<p>你可以在示例程序 <strong>3strings.rb</strong> 中发现许多种字符串分隔符。不用说，有时候使用一些深奥的字符（比如换行符和星号）分割字符串很有用，但在许多情况下这些方式的缺点可能会掩盖掉其优点。</p>
<h3 id="-">反引号</h3>
<p>一个其它类型的字符串值得特别提及：一个由反引号括起来的字符串——也就是在键盘左上角的向内指向的引号字符 <code>`</code>。</p>
<p>Ruby 认为任何由反引号括起来的都是一个可以使用 <code>print</code> 或 <code>puts</code> 方法传递给操作系统执行的命令。到目前为止，你可能已经猜到 Ruby 提供了不仅仅一种方式去实现这些。事实证明，<code>%x/some command/</code> 与 <code><code>somecommand</code></code> 具有相同的效果，当然 <code>%x{some command}</code> 也是如此。例如，在 Windows 操作系统上，如下所示的三行代码都是将命令 <strong>dir</strong> 传递给操作系统执行，显示目录列表：</p>
<div class="code-file clearfix"><span>4backquotes.rb</span></div>

<pre><code><span class="hljs-function"><span class="hljs-title">puts</span><span class="hljs-params">(`dir`)</span></span>
<span class="hljs-function"><span class="hljs-title">puts</span><span class="hljs-params">(%x/dir/)</span></span>
<span class="hljs-function"><span class="hljs-title">puts</span><span class="hljs-params">(%x{dir})</span></span></code></pre><p>你也可以在双引号字符串中嵌入命令，如下所示：</p>
<pre><code><span class="hljs-function"><span class="hljs-title">print</span><span class="hljs-params">( <span class="hljs-string">"Goodbye #{%x{calc}}"</span> )</span></span></code></pre><p>如果你这么做，要小心的是，命令首先会被执行。你的 Ruby 程序会进行等待，直到开始的进程终止。在这种情况下，计算器将先弹出来。你可以做一些计算，只有当你关闭计算器的时候，字符串 “Goodbye” 才会显示。</p>
<h3 id="-">字符串处理</h3>
<p>在结束字符串这个话题之前，我们将快速查看一看字符串的处理操作。</p>
<h4 id="-">连接</h4>
<div class="code-file clearfix"><span>string_concat.rb</span></div>

<p>你可以使用 <code>&lt;&lt;</code> 或 <code>+</code>，或者说在中间放置一个空格来连接字符串。这里有三个字符串连接示例，在每一种情况下 <code>s</code> 都被赋值为字符串 “Hello World” ：</p>
<pre><code><span class="hljs-attr">s</span> = <span class="hljs-string">"Hello "</span> &lt;&lt; <span class="hljs-string">"world"</span>
<span class="hljs-attr">s</span> = <span class="hljs-string">"Hello "</span> + <span class="hljs-string">"world"</span>
<span class="hljs-attr">s</span> = <span class="hljs-string">"Hello "</span> <span class="hljs-string">"world"</span></code></pre><p>但是请注意，当你使用 <code>&lt;&lt;</code> 方法时，你可以直接附加一个整数（0到255），而不必先将它转换为字符串；当使用 <code>+</code> 或者空格时，整数必须使用 <code>to_s</code> 方法先转换为字符串。</p>
<div class="note">
<p class="h4" style="font-weight: bold;">关于逗号</p>
<p>
    你有时可能会看到 Ruby 代码使用逗号分割来分割字符串或者其它类型数据。在某些情况下，这些逗号似乎有连接字符串的效果。例如，下面的代码一眼看上去似乎是创建和显示了一个由三个子字符串加整数组成的字符串：
</p>

<pre><code>s4 = <span class="hljs-string">"This "</span>, <span class="hljs-string">"is"</span>, <span class="hljs-string">" not a string!"</span>, <span class="hljs-number">10</span>
<span class="hljs-function"><span class="hljs-title">print</span><span class="hljs-params">(<span class="hljs-string">"print (s4):"</span>, s4, <span class="hljs-string">"\n"</span>)</span></span></code></pre><p>
    事实上，用逗号分割的列表是创建了一个数组——一个基于字符串的有序列表。<b>string_concat.rb</b> 程序包含的示例证明了这一点。
</p>
<p>
    请注意，当你将一个数组传递给一个方法比如<code>puts</code>，数组中的每个元素将被单独处理。你可以像下面一样将<code>x</code>传递给<code>puts</code>：
</p>

<pre><code><span class="hljs-function"><span class="hljs-title">puts</span><span class="hljs-params">(x)</span></span></code></pre><p>在这种情况下，输出将会是：</p>

<pre><code>This
<span class="hljs-keyword">is</span>
<span class="hljs-keyword">not</span> a <span class="hljs-built_in">string</span>!
<span class="hljs-number">10</span></code></pre><p>我们将在下一章中更深入的研究数组。</p>
</div>

<h4 id="-">字符串赋值</h4>
<p>Ruby 的 String 类提供了许多有用的字符串处理方法。大多数的方法将会创建一个新的字符串对象。例如，在下面的代码中，第二行左侧的 <code>s</code> 与右侧的 <code>s</code> 不是同一个对象：</p>
<pre><code><span class="hljs-attr">s</span> = <span class="hljs-string">"hello world"</span>
<span class="hljs-attr">s</span> = s + <span class="hljs-string">"!"</span></code></pre><div class="code-file clearfix"><span>string_assign.rb</span></div>

<p>一些字符串方法实际上是在不创建新的字符串对象的情况下改变其本身。这些方法通常以感叹号结尾（例如，<code>capitalize!</code>）。</p>
<p>如果有疑问，可以使用 <code>object_id</code> 方法来检查对象。我已经在 <strong>string_assign.rb</strong> 程序中提供了几个不需要创建新字符串对象的操作示例。运行它们并且在字符串操作执行完之后检查 <code>s</code> 的 <code>object_id</code>。</p>
<h4 id="-">字符串索引</h4>
<p>你可以将字符串视为一个字符数组，并使用方括号以及索引查找在该数组中特定索引处的字符。Ruby 中的字符串和数组索引是从 0 开始的。所以，要将字符串 <code>s</code> “Hello world” 中的 “e” 替换为 “a”，你应该在索引 1 处赋值一个新的字符：</p>
<pre><code><span class="hljs-attr">s[1]</span> = <span class="hljs-string">'a'</span></code></pre><p>但是，如果你要在一个字符串中使用索引查找特定位置的字符，Ruby 不会返回这个字符本身，返回的是该字符的 ASCII 值：</p>
<pre><code>s = <span class="hljs-string">"Hello world"</span>
puts(s[1])  <span class="hljs-comment"># prints out 101 – the ASCII value of 'e'</span></code></pre><p>为了获得实际的字符，可以这么做：</p>
<pre><code>s = <span class="hljs-string">"Hello world"</span>
puts(s[1,1])  <span class="hljs-comment"># prints out 'e'</span></code></pre><p>这将告诉 Ruby 将字符串中索引 1 处的字符返回。如果你想要返回索引 1 处开始的3个字符，你可以输入：</p>
<pre><code><span class="hljs-built_in">puts</span>(s[<span class="hljs-number">1</span>,<span class="hljs-number">3</span>])  <span class="hljs-meta"># prints <span class="hljs-meta-string">"ell"</span></span></code></pre><p>这告诉 Ruby 返回从索引 1 处开始接下来的3个字符。或者，你也可以使用双点符号 “范围（range）”来表示:</p>
<pre><code><span class="hljs-built_in">puts</span>(s[<span class="hljs-number">1.</span><span class="hljs-number">.3</span>])  <span class="hljs-meta"># also prints <span class="hljs-meta-string">"ell"</span></span></code></pre><div class="note">
    关于范围（Ranges），你可以参阅本章末尾的<strong>深入探索</strong>部分。
</div>

<p>字符串还可以使用负值索引，在这种情况下，-1 代表最后一个字符的位置，并且可以再次指定要返回的字符数：</p>
<pre><code><span class="hljs-built_in">puts</span>(s[<span class="hljs-number">-1</span>,<span class="hljs-number">1</span>])  <span class="hljs-meta"># prints <span class="hljs-meta-string">'d'</span></span>
<span class="hljs-built_in">puts</span>(s[<span class="hljs-number">-5</span>,<span class="hljs-number">1</span>])  <span class="hljs-meta"># prints <span class="hljs-meta-string">'w'</span></span>
<span class="hljs-built_in">puts</span>(s[<span class="hljs-number">-5</span>,<span class="hljs-number">5</span>])  <span class="hljs-meta"># prints <span class="hljs-meta-string">"world"</span></span></code></pre><div class="code-file clearfix"><span>string_index.rb</span></div>

<p>使用减号指定范围时，起始和终止索引必须均用负值：</p>
<pre><code>puts(s[<span class="hljs-number">-5.</span><span class="hljs-number">.5</span>])  # <span class="hljs-keyword">this</span> prints an empty <span class="hljs-built_in">string</span>!
puts(s[<span class="hljs-number">-5.</span>.<span class="hljs-number">-1</span>])  # prints <span class="hljs-string">"world"</span></code></pre><div class="code-file clearfix"><span>string_methods.rb</span></div>

<p>最后，你可能需要尝试一些可用于操作字符串的标准方法。这些方法包括改变字符串大小写，反转字符串，插入子字符串，删除重复字符等等。我在 <strong>string_methods.rb</strong> 提供了几个示例。</p>
<h4 id="-chop-chomp">删除换行符 chop 与 chomp</h4>
<p>一些方便的字符串处理方法值得提及一下。<code>chop</code> 与 <code>chomp</code> 方法可用于从字符串的末尾删除字符。<code>chop</code> 方法会返回一个字符串，这个字符串是删除最后一个字符得到的，但如果在字符串末尾处发现了回车符和换行符 “\r\n” 则删除一个回车符或换行符之后返回字符串。<code>chomp</code> 方法返回一个字符串，这个字符串是删除了末尾一个回车符或换行符得到的。</p>
<p>这些方法在你需要删除用户输入或者文件输入的换行符时是非常有用的。例如，当你使用 <code>gets</code> 方法读取一行文本时，它将返回该文本以及在末尾的“记录分隔符”，默认地通常是换行符。</p>
<div class="note">
    <p class="h4" style="font-weight: bold;">记录分隔符- $/</p>
    <p>
        Ruby 预定义了一个变量 <code>$/</code> 来作为“记录分隔符”。这个变量被用于一些方法中，例如 <code>gets</code> 和 <code>chomp</code> 中。<code>gets</code> 方法读入一个字符串时将会包含一个记录分隔符。<code>chomp</code> 方法将会返回一个字符串，该字符串末尾存在记录分隔符时删除后返回，不存在时直接返回未修改的原始字符串。如果你愿意，可以重新定义记录分隔符，如下所示：
    </p>

<pre><code><span class="hljs-variable">$/</span>=<span class="hljs-string">"*"</span>  <span class="hljs-comment"># the "*" character is now the record separator</span></code></pre><p>当你重新定义了记录分隔符之后，新的字符或字符串现在将会在一些方法中被使用，例如 <code>gets</code> 和 <code>chomp</code> 方法。例如：</p>
<pre><code>$/= <span class="hljs-string">"world"</span>
s = gets()  #<span class="hljs-built_in"> user </span>enters <span class="hljs-string">"Had we but world enough and time…"</span>
puts(s)  # displays <span class="hljs-string">"Had we but world"</span></code></pre></div>

<p>你可以使用 <code>chop</code> 和 <code>chomp</code> 方法来删除换行符。在大多数情况下，<code>chomp</code> 方法是最好的，因为它不会删除最后的字符，除非末尾是记录分隔符，而 <code>chop</code> 方法无论最后一个字符是什么都会删除。这里是一些示例：</p>
<div class="code-file clearfix"><span>chop_chomp.rb</span></div>

<pre><code><span class="hljs-comment"># <span class="hljs-doctag">Note:</span> s1 includes a carriage return and linefeed</span>
s1 = <span class="hljs-string">"Hello world
"</span>
s2 = <span class="hljs-string">"Hello world"</span>
s1.chop  # returns <span class="hljs-string">"Hello world"</span>
s1.chomp # returns <span class="hljs-string">"Hello world"</span>
s2.chop  # returns <span class="hljs-string">"Hello worl"</span> –<span class="hljs-built_in"> note </span>the missing <span class="hljs-string">"d"</span>!
s2.chomp # returns <span class="hljs-string">"Hello world"</span></code></pre><p><code>chomp</code> 方法允许你指定要用做分隔符的字符或字符串：</p>
<pre><code>s2.chomp(<span class="hljs-string">"rld"</span>)  <span class="hljs-meta"># returns <span class="hljs-meta-string">"Hello wo"</span></span></code></pre><h4 id="-">格式化字符串</h4>
<p>Ruby 提供了 <code>v</code> 方法来打印包含以百分号 <strong>%</strong> 开头的说明符的“格式化字符串”。格式化字符串之后可以是一个或多个用逗号分隔的数据项；数据项的列表应与格式说明符的类型相匹配。实际数据项替换字符串中匹配的说明符，并相应地进行格式化。这是一些常见的格式说明符：</p>
<pre><code><span class="hljs-tag">%<span class="hljs-selector-tag">d</span></span> – decimal number
<span class="hljs-tag">%<span class="hljs-selector-tag">f</span></span> – floating point number
<span class="hljs-tag">%<span class="hljs-selector-tag">o</span></span> – octal number
<span class="hljs-tag">%<span class="hljs-selector-tag">p</span></span> – inspect object
<span class="hljs-tag">%<span class="hljs-selector-tag">s</span></span> – string
<span class="hljs-tag">%<span class="hljs-selector-tag">x</span></span> – hexadecimal number</code></pre><p>你可以通过在浮点数说明符 <strong>%f</strong> 前面放置一个点号来控制浮点精度。例如，这将显示两位浮点值：</p>
<pre><code><span class="hljs-keyword">printf</span>(<span class="hljs-string">"%0.02f"</span>, <span class="hljs-number">10.12945</span>)  <span class="hljs-comment"># displays 10.13</span></code></pre><h2 id="-">深入探索</h2>
<h3 id="-">范围</h3>
<p>在 Ruby 中，Range 是一个表示指定的起始和终止值之间一组数的类。通常，使用整数定义范围，但也可以使用其它有序值（比如浮点数或字符）来定义范围。值可以是负的，尽管如此，你应该注意起始值应该始终小于终止值。这有一些示例：</p>
<div class="code-file clearfix"><span>ranges.rb</span></div>

<pre><code><span class="hljs-attr">a</span> = (<span class="hljs-number">1</span>..<span class="hljs-number">10</span>)
<span class="hljs-attr">b</span> = (-<span class="hljs-number">10</span>..-<span class="hljs-number">1</span>)
<span class="hljs-attr">c</span> = (-<span class="hljs-number">10</span>..<span class="hljs-number">10</span>)
<span class="hljs-attr">d</span> = (<span class="hljs-string">'a'</span>..<span class="hljs-string">'z'</span>)</code></pre><p>你也可以使用三个点而不是两个点指定范围：这将创建一个不包含终止值范围：</p>
<pre><code>d = (<span class="hljs-string">'a'</span>..<span class="hljs-string">'z'</span>)   # this two-dot range = <span class="hljs-string">'a'</span>..<span class="hljs-string">'z'</span>
e = (<span class="hljs-string">'a'</span>...<span class="hljs-string">'z'</span>)   # this three-dot range = <span class="hljs-string">'a'</span>..<span class="hljs-string">'y'</span></code></pre><p>你可以使用 <code>to_a</code> 方法创建一个由范围定义的数的数组：</p>
<pre><code>(<span class="hljs-number">1.</span><span class="hljs-number">.10</span>).to_a</code></pre><p>请注意，由于两个浮点数之间的数不是有限的，所以 <code>to_a</code> 方法并没有为浮点数所定义。</p>
<div class="code-file clearfix"><span>str_range.rb</span></div>

<p>你甚至可以创建字符串范围，你需要非常的小心，这样做的话最终可能会超出你的预想。例如，看看你是否知道这个范围指定的值：</p>
<pre><code><span class="hljs-attr">str_range</span> = (<span class="hljs-string">'abc'</span>..<span class="hljs-string">'def'</span>)</code></pre><p>一眼看去，从&quot;abc&quot;到&quot;def&quot;这个范围的值可能不多。实际上，这个范围之间的值不少于 2110 个！它们具体如下：&quot;abc&quot;、&quot;abd&quot;、&quot;abe&quot;等等，直到&quot;a&quot;结束；然后再从&quot;b&quot;开始，&quot;baa&quot;、&quot;bab&quot;、&quot;bac&quot;等等。准确的说，这种范围是不常用的，最好要非常小心或者直接不使用。</p>
<h3 id="-">范围迭代器</h3>
<p>你可以使用范围从起始值迭代到终止值。例如，以下是将数字从1到10打印出来的方法：</p>
<div class="code-file clearfix"><span>for_to.rb</span></div>

<pre><code><span class="hljs-keyword">for</span> i <span class="hljs-keyword">in</span> (<span class="hljs-number">1</span>..<span class="hljs-number">10</span>) <span class="hljs-keyword">do</span>
    puts( i )
<span class="hljs-keyword">end</span></code></pre><h3 id="heredocs">HereDocs</h3>
<p>虽然你可以在单双引号之间写跨行的长字符串，但许多 Ruby 程序员更喜欢使用名为&quot;heredoc&quot;这种替代类型的字符串。hererdoc 是一个以特定结束标记开始的文本块，这可以是你自己选择的结束标记。这里，我选择了 EODOC 作为结束标记：</p>
<div class="code-file clearfix"><span>heredoc.rb</span></div>

<pre><code><span class="hljs-attr">hdoc1</span> = &lt;&lt;EODOC</code></pre><p>这告诉 Ruby，直到遇到结束标记时所有行都是单个字符串。这个字符串被赋值给 <code>hdoc1</code> 变量。这是一个完整的例子：</p>
<pre><code>hdoc1 = &lt;&lt;EODOC
I wandered lonely <span class="hljs-keyword">as</span> a <span class="hljs-comment">#{"cloud".upcase},</span>
That floats <span class="hljs-keyword">on</span> high o'er vale <span class="hljs-keyword">and</span> hill...
EODOC</code></pre><p>默认情况下，heredocs 被视为双引号字符串，所以表达式 <code>#{&quot;cloud&quot;.upcase}</code> 将会被执行。如果你想要一个 heredoc 被视为单引号字符串，在单引号之间指定结束标记：</p>
<pre><code>hdoc2 =  &lt;&lt;'EODOC'
I wandered lonely <span class="hljs-keyword">as</span> a <span class="hljs-comment">#{"cloud".upcase},</span>
That floats <span class="hljs-keyword">on</span> high o'er vale <span class="hljs-keyword">and</span> hill...
EODOC</code></pre><p>默认情况下，heredoc 的结束标记必须与左侧对齐。如果你想缩进，应该在指定结束标记时使用 <code>&lt;&lt;-</code> 来代替 <code>&lt;&lt;</code>：</p>
<pre><code>hdoc3 = &lt;&lt;-EODOC
I wandered lonely <span class="hljs-keyword">as</span> a <span class="hljs-comment">#{"cloud".upcase},</span>
That floats <span class="hljs-keyword">on</span> high o'er vale <span class="hljs-keyword">and</span> hill...
    EODOC</code></pre><p>你可以自己选择适当的结束标记，使用保留字也是可以的（但这似乎不是明智的做法！）。</p>
<pre><code>hdoc4 = &lt;&lt;def
I wandered lonely <span class="hljs-keyword">as</span> a <span class="hljs-comment">#{"cloud".upcase},</span>
That floats <span class="hljs-keyword">on</span> high o'er vale <span class="hljs-keyword">and</span> hill...
def</code></pre><p>一个被赋值为 heredoc 的变量也可以像其它字符串变量一样使用：</p>
<pre><code><span class="hljs-function"><span class="hljs-title">puts</span><span class="hljs-params">(hdoc1)</span></span></code></pre><h3 id="-">字符串字面量</h3>
<p>如本章前面所述，你可以选择使用 <strong>%q/</strong> 和 <strong>/</strong> 来分割单引号字符串，以及使用 <strong>%Q/</strong> 和 <strong>/</strong> 来分割双引号字符串。</p>
<p>Ruby 提供了类似的方法来定义反引号字符串、正则表达式（regular expressions）、符号（symbols）和数组（arrays）的分隔符。以这种方式定义字符串数组特别的有用，这样避免了为每个元素都要输入字符串分隔符。这里是一些字符串字面量分隔符的参考：</p>
<pre><code><span class="hljs-tag">%<span class="hljs-selector-tag">q</span></span>/   /
<span class="hljs-tag">%<span class="hljs-selector-tag">Q</span></span>/   /
<span class="hljs-tag">%</span>/   /
<span class="hljs-tag">%<span class="hljs-selector-tag">w</span></span>/   /
<span class="hljs-tag">%<span class="hljs-selector-tag">W</span></span>/   /
<span class="hljs-tag">%<span class="hljs-selector-tag">r</span></span>|   |
<span class="hljs-tag">%<span class="hljs-selector-tag">s</span></span>/   /
<span class="hljs-tag">%<span class="hljs-selector-tag">x</span></span>/   /</code></pre><p>请注意，你可以选择要使用的分隔符。我选择了 <strong>/</strong>，而正则表达式则使用了 <strong>|</strong>（因为 <strong>/</strong> 是一个常规的正则表达式分隔符），同样地我也可以使用方括号、星号、&amp; 或者其它符号（例如 <code>%W*dog cat＃{1 + 2}*</code> 或 <code>%s&amp;dog&amp;</code>）。这是一些示例：</p>
<div class="code-file clearfix"><span>literals.rb</span></div>

<pre><code>p %q/dog cat #{<span class="hljs-number">1</span>+<span class="hljs-number">2</span>}/  #=&gt; <span class="hljs-string">"dog cat \#{1+2}"</span>
p %Q/dog cat #{<span class="hljs-number">1</span>+<span class="hljs-number">2</span>}/  #=&gt; <span class="hljs-string">"dog cat 3"</span>
p %/dog cat #{<span class="hljs-number">1</span>+<span class="hljs-number">2</span>}/  #=&gt; <span class="hljs-string">"dog cat 3"</span>
p %w/dog cat #{<span class="hljs-number">1</span>+<span class="hljs-number">2</span>}/  #=&gt; [<span class="hljs-string">"dog"</span>, <span class="hljs-string">"cat"</span>, <span class="hljs-string">"\#{1+2}"</span>]
p %W/dog cat #{<span class="hljs-number">1</span>+<span class="hljs-number">2</span>}/  #=&gt; [<span class="hljs-string">"dog"</span>, <span class="hljs-string">"cat"</span>, <span class="hljs-string">"3"</span>]
p %r|^[a-z]*$|  #=&gt; /^[a-z]*$/
p %s/dog/ #=&gt; :dog
p %x/vol/ #=&gt; <span class="hljs-string">" Volume in drive C is OS [etc...]"</span></code></pre>